In a data processing system utilizing a shared bus coupling multiple bus devices (e.g. processors, input/output ("I/O") channel controllers, high performance I/O devices) with a memory system, it is common practice for a bus device to read, or access a portion of data stored in the memory system and upon receiving this data, to write the data into the device's cache, i.e. fast local memory. This allows the bus device to gain quick access to this data, if required again in the near future. If the bus device needs to modify this previously accessed data, which is still present in its cache, it is also common practice to modify the cache data but not modify the data in the memory system. However, if another bus device requires access to this portion of data, then retrieval of that data from the memory system will result in a retrieval of an "old" version of the data, since the most current version of the data is modified in the other bus device's cache. This is known in the art as "cache inconsistency."
Prior data processing systems have employed "snooping" capabilities within the bus devices in order to alleviate this problem. "Snooping" bus devices monitor addresses delivered on the shared bus by other bus devices, and compare these monitored addresses to addresses of data currently held within their internal or attached caches. (Snooping is well-known in the art.) For example, if a first bus device invokes a read operation on the shared bus, a second bus device will snoop the address of the data to be read from the memory system and compare the address to addresses of data currently held in the second bus device's cache. If the second bus device currently holds that addressed data, whether in an unmodified or modified form, it may then signal the first bus device of the situation.
A common method of alleviating the previously described cache inconsistency between modified data in a cache and the memory system data is to have the snooper issue a "retry" response to the device that initiated the bus read operation. This, then cancels the memory read operation and the snooper would in turn arbitrate for the system bus and issue a bus write operation to update the memory system with the valid cache data. The snooper would continuously retry the bus read operation until the bus write operation has been completed by the snooper.
Another more efficient method is to have the snooper which retried the read operation to provide the data within a deterministic "data intervention" window after the retry/null response window. (Data intervention is well known in the art.) This requires that the memory system provide read data (due to a null response) after the data intervention window. This then allows the snooper to retry, at least once, the bus read operation, access the modified cache data, and upon receiving another read operation, respond null and provide the data in the data intervention window.
However, the aforementioned technique limits the memory system from providing data prior to the data intervention window. Furthermore, the snooper may retry the bus read operation several times before providing the read data, thus inefficiently utilizing the system bus bandwidth.
Thus, there is a need in the art for a more efficient technique for transferring data to a requesting bus device when the requested data has been modified by another bus device.